// This file is part of Eigen, a lightweight C++ template library
// for linear algebra.
//
// Copyright (C) 2008-2016 Gael Guennebaud <gael.guennebaud@inria.fr>
//
// This Source Code Form is subject to the terms of the Mozilla
// Public License v. 2.0. If a copy of the MPL was not distributed
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

#ifndef EIGEN_NULLARY_FUNCTORS_H
#define EIGEN_NULLARY_FUNCTORS_H

namespace Eigen {

namespace internal {

template<typename Scalar>
struct scalar_constant_op
{
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE scalar_constant_op(const scalar_constant_op& other)
		: m_other(other.m_other)
	{
	}
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE scalar_constant_op(const Scalar& other)
		: m_other(other)
	{
	}
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()() const { return m_other; }
	template<typename PacketType>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const PacketType packetOp() const
	{
		return internal::pset1<PacketType>(m_other);
	}
	const Scalar m_other;
};
template<typename Scalar>
struct functor_traits<scalar_constant_op<Scalar>>
{
	enum
	{
		Cost = 0 /* as the constant value should be loaded in register only once for the whole expression */,
		PacketAccess = packet_traits<Scalar>::Vectorizable,
		IsRepeatable = true
	};
};

template<typename Scalar>
struct scalar_identity_op
{
	EIGEN_EMPTY_STRUCT_CTOR(scalar_identity_op)
	template<typename IndexType>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(IndexType row, IndexType col) const
	{
		return row == col ? Scalar(1) : Scalar(0);
	}
};
template<typename Scalar>
struct functor_traits<scalar_identity_op<Scalar>>
{
	enum
	{
		Cost = NumTraits<Scalar>::AddCost,
		PacketAccess = false,
		IsRepeatable = true
	};
};

template<typename Scalar, bool IsInteger>
struct linspaced_op_impl;

template<typename Scalar>
struct linspaced_op_impl<Scalar, /*IsInteger*/ false>
{
	typedef typename NumTraits<Scalar>::Real RealScalar;

	EIGEN_DEVICE_FUNC linspaced_op_impl(const Scalar& low, const Scalar& high, Index num_steps)
		: m_low(low)
		, m_high(high)
		, m_size1(num_steps == 1 ? 1 : num_steps - 1)
		, m_step(num_steps == 1 ? Scalar() : Scalar((high - low) / RealScalar(num_steps - 1)))
		, m_flip(numext::abs(high) < numext::abs(low))
	{
	}

	template<typename IndexType>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(IndexType i) const
	{
		if (m_flip)
			return (i == 0) ? m_low : Scalar(m_high - RealScalar(m_size1 - i) * m_step);
		else
			return (i == m_size1) ? m_high : Scalar(m_low + RealScalar(i) * m_step);
	}

	template<typename Packet, typename IndexType>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(IndexType i) const
	{
		// Principle:
		// [low, ..., low] + ( [step, ..., step] * ( [i, ..., i] + [0, ..., size] ) )
		if (m_flip) {
			Packet pi = plset<Packet>(Scalar(i - m_size1));
			Packet res = padd(pset1<Packet>(m_high), pmul(pset1<Packet>(m_step), pi));
			if (EIGEN_PREDICT_TRUE(i != 0))
				return res;
			Packet mask = pcmp_lt(pset1<Packet>(0), plset<Packet>(0));
			return pselect<Packet>(mask, res, pset1<Packet>(m_low));
		} else {
			Packet pi = plset<Packet>(Scalar(i));
			Packet res = padd(pset1<Packet>(m_low), pmul(pset1<Packet>(m_step), pi));
			if (EIGEN_PREDICT_TRUE(i != m_size1 - unpacket_traits<Packet>::size + 1))
				return res;
			Packet mask = pcmp_lt(plset<Packet>(0), pset1<Packet>(unpacket_traits<Packet>::size - 1));
			return pselect<Packet>(mask, res, pset1<Packet>(m_high));
		}
	}

	const Scalar m_low;
	const Scalar m_high;
	const Index m_size1;
	const Scalar m_step;
	const bool m_flip;
};

template<typename Scalar>
struct linspaced_op_impl<Scalar, /*IsInteger*/ true>
{
	EIGEN_DEVICE_FUNC linspaced_op_impl(const Scalar& low, const Scalar& high, Index num_steps)
		: m_low(low)
		, m_multiplier((high - low) / convert_index<Scalar>(num_steps <= 1 ? 1 : num_steps - 1))
		, m_divisor(convert_index<Scalar>((high >= low ? num_steps : -num_steps) + (high - low)) /
					((numext::abs(high - low) + 1) == 0 ? 1 : (numext::abs(high - low) + 1)))
		, m_use_divisor(num_steps > 1 && (numext::abs(high - low) + 1) < num_steps)
	{
	}

	template<typename IndexType>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(IndexType i) const
	{
		if (m_use_divisor)
			return m_low + convert_index<Scalar>(i) / m_divisor;
		else
			return m_low + convert_index<Scalar>(i) * m_multiplier;
	}

	const Scalar m_low;
	const Scalar m_multiplier;
	const Scalar m_divisor;
	const bool m_use_divisor;
};

// ----- Linspace functor ----------------------------------------------------------------

// Forward declaration (we default to random access which does not really give
// us a speed gain when using packet access but it allows to use the functor in
// nested expressions).
template<typename Scalar>
struct linspaced_op;
template<typename Scalar>
struct functor_traits<linspaced_op<Scalar>>
{
	enum
	{
		Cost = 1,
		PacketAccess =
			(!NumTraits<Scalar>::IsInteger) && packet_traits<Scalar>::HasSetLinear && packet_traits<Scalar>::HasBlend,
		/*&& ((!NumTraits<Scalar>::IsInteger) || packet_traits<Scalar>::HasDiv),*/ // <- vectorization for integer is
																				   // currently disabled
		IsRepeatable = true
	};
};
template<typename Scalar>
struct linspaced_op
{
	EIGEN_DEVICE_FUNC linspaced_op(const Scalar& low, const Scalar& high, Index num_steps)
		: impl((num_steps == 1 ? high : low), high, num_steps)
	{
	}

	template<typename IndexType>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Scalar operator()(IndexType i) const
	{
		return impl(i);
	}

	template<typename Packet, typename IndexType>
	EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const Packet packetOp(IndexType i) const
	{
		return impl.template packetOp<Packet>(i);
	}

	// This proxy object handles the actual required temporaries and the different
	// implementations (integer vs. floating point).
	const linspaced_op_impl<Scalar, NumTraits<Scalar>::IsInteger> impl;
};

// Linear access is automatically determined from the operator() prototypes available for the given functor.
// If it exposes an operator()(i,j), then we assume the i and j coefficients are required independently
// and linear access is not possible. In all other cases, linear access is enabled.
// Users should not have to deal with this structure.
template<typename Functor>
struct functor_has_linear_access
{
	enum
	{
		ret = !has_binary_operator<Functor>::value
	};
};

// For unreliable compilers, let's specialize the has_*ary_operator
// helpers so that at least built-in nullary functors work fine.
#if !((EIGEN_COMP_MSVC > 1600) || (EIGEN_GNUC_AT_LEAST(4, 8)) || (EIGEN_COMP_ICC >= 1600))
template<typename Scalar, typename IndexType>
struct has_nullary_operator<scalar_constant_op<Scalar>, IndexType>
{
	enum
	{
		value = 1
	};
};
template<typename Scalar, typename IndexType>
struct has_unary_operator<scalar_constant_op<Scalar>, IndexType>
{
	enum
	{
		value = 0
	};
};
template<typename Scalar, typename IndexType>
struct has_binary_operator<scalar_constant_op<Scalar>, IndexType>
{
	enum
	{
		value = 0
	};
};

template<typename Scalar, typename IndexType>
struct has_nullary_operator<scalar_identity_op<Scalar>, IndexType>
{
	enum
	{
		value = 0
	};
};
template<typename Scalar, typename IndexType>
struct has_unary_operator<scalar_identity_op<Scalar>, IndexType>
{
	enum
	{
		value = 0
	};
};
template<typename Scalar, typename IndexType>
struct has_binary_operator<scalar_identity_op<Scalar>, IndexType>
{
	enum
	{
		value = 1
	};
};

template<typename Scalar, typename IndexType>
struct has_nullary_operator<linspaced_op<Scalar>, IndexType>
{
	enum
	{
		value = 0
	};
};
template<typename Scalar, typename IndexType>
struct has_unary_operator<linspaced_op<Scalar>, IndexType>
{
	enum
	{
		value = 1
	};
};
template<typename Scalar, typename IndexType>
struct has_binary_operator<linspaced_op<Scalar>, IndexType>
{
	enum
	{
		value = 0
	};
};

template<typename Scalar, typename IndexType>
struct has_nullary_operator<scalar_random_op<Scalar>, IndexType>
{
	enum
	{
		value = 1
	};
};
template<typename Scalar, typename IndexType>
struct has_unary_operator<scalar_random_op<Scalar>, IndexType>
{
	enum
	{
		value = 0
	};
};
template<typename Scalar, typename IndexType>
struct has_binary_operator<scalar_random_op<Scalar>, IndexType>
{
	enum
	{
		value = 0
	};
};
#endif

} // end namespace internal

} // end namespace Eigen

#endif // EIGEN_NULLARY_FUNCTORS_H
